\section{Jaringan Saraf Tiruan}
\label{sec:jst}

Jaringan Saraf Tiruan (JST) atau Artificial Neural Networks (ANN)
merupakan suatu sistem yang dibangun atas dasar cara kerja jaringan saraf
manusia. Awal perkembangannya dimotivasi oleh kemampuan pengenalan dari manusia
(otak) dimana cara perhitungannya sangat jauh berbeda dengan sistem komputer
digital. JSt merupakan sistem adaptif yang dapat mengubah strukturnya
untuk memecahkan masalah berdasarkan informasi eksternal maupun internal
yang mengalir melalui jaringan tersebut. 

Menurut S. Haykin \cite{haykin-1994}, sebuah jaringan saraf adalah sebuah
prosesor yang terdistribusi paralel dan mempuyai kecenderungan untuk menyimpan
pengetahuan yang didapatkannya dari pengalaman dan membuatnya tetap tersedia
untuk digunakan. Hal ini menyerupai kerja otak dalam dua hal yaitu: (1)
Pengetahuan diperoleh oleh jaringan melalui suatu proses belajar. (2) Kekuatan
hubungan antar sel saraf yang dikenal dengan bobot sinapsis digunakan untuk
menyimpan pengetahuan.
Jaringan saraf merupakan suatu mesin yang digunakan untuk memodelkan kerja otak
dalam menyelesaikan suatu permasalahan. Jaringan tersebut disusun dari
sekumpulan unit pemroses yang disebut neuron dan untuk meningkatkan
kemampuan-nya, dilakukan proses pembelajaran dengan menggunakan suatu algoritma
tertentu (learning algorithm) dimana tujuannya adalah untuk memodifikasi
kekuatan hubungan antar neuron (bobot) dalam jaringan sesuai dengan goal yang
telah ditentukan.

Keuntungan dari penggunaan JST adalah kemampuannya dalam beradaptasi melalui
proses pembelajaran dan kemampuan generalisasi, dalam artian jaringan saraf
mampu memberikan hasil dari input yang tidak diketahui sebelumnya. Berikut
adalah beberapa kemampuan yang dapat diberikan melalui penggunaan JST menurut S.
Haykin \cite{haykin-1994}:
\begin{enumerate}
  \item Non Linier : jaringan saraf dapat menangani permasalahan baik linier
  maupun non linier.
  \item Pemetaan Input-Output : dalam paradigma pembelajaran dengan arahan
  (supervised learning), modifikasi bobot disesuaikan dengan output yang
  diinginkan sebelumnya (label pada data sampel).
  \item Adaptif : jaringan saraf memiliki kemampuan untuk mengadaptasi bobot
  sinapsisnya sesuai dengan lingkungannya. Jaringan saraf pada umumnya melalui
  proses pembelajaran terhadap suatu lingkungan tertentu, dan dapat diajarkan
  kembali (re-train) untuk melakukan penyesuaian terhadap lingkungannya. 
%   \item Toleransi terhadap kesalahan.
\end{enumerate}

Konsep JST dimodelkan secara matematis dan direpresentasikan melalui suatu unit
pemrosesan, yaitu neuron. terdapat tiga elemen dasar pada model neuron,
seperti yang terlihat pada \pic~\ref{fig:neuron} yaitu
\begin{itemize}
  \item Sinapsis, koneksi antar neuron dimana direpresentasikan dengan suatu
  bobot untuk menunjukkan kekuatan dari koneksi tersebut.
  \item Penjumlah, yang berfungsi untuk menjumlahkan sinyal, yang
  biasanya dalam hal ini perkalian antara bobot dengan sinyal masukan.
  \item Setiap neuron menerapkan fungsi aktivasi terhadap jumlah dari perkalian
  antara sinyal input dengan bobot neuron sebelumnya, untuk menentukan nilai
  output. Fungsi aktivasi ini pada umumnya membatasi nilai output dari neuron,
  menormalisasi output dalam range [0,1] atau [-1,1].
\end{itemize}

\addFigure{width=0.5\textwidth}{pics/neuron.png}{fig:neuron}{Model neuron non
linier \cite[p.~33]{haykin-1994}}

Paradigma pembelajaran JST secara umum dibagi menjadi dua kelompok utama yaitu
pembelajaran dengan pengarahan (supervised) dan pembelajaran tidak dengan
pengarahan (unsupervised).
\begin{itemize}
  \item Supervised learning : pembelajaran dengan pengarahan adalah hasil
  keluaran komputasi dari JST akan dibandingkan dengan hasil keluaran
  sesungguhnya, sehingga dengan selisih antara keduanya; proses penyesuaian
  bobot dalam jaringan dapat dilakukan. Untuk itu tipe ini memerlukan suatu data
  pelatihan yang berisikan data masukan serta target keluaran dari latihan. JST,
  tipe ini misalnya Multi Layer Perceptron, Learning Vector Quantization (LVQ), dll.

  \item Unsupervised learning : pembelajaran dengan tanpa pelatihan
  adalah proses pembelajaran JST dimana tidak memerlukan
  informasi target, cara pembelajarannya adalah jaringan akan menyesuaikan
  bobotnya tanpa campur tangan dari faktor luar dan berusaha menentukan sendiri
  masuk kedalam kelompok mana. Jaringan macam ini misalnya Kohonen
  Self-Organizing Maps (SOM).\end{itemize}
\subsection{Pembelajaran berbasis kompetisi}
Pembelajaran berbasis kompetisi atau \textit{competitive based learning}, adalah
suatu metode pembelajaran dimana neuron pada output layer berkompetisi satu sama lain
untuk menjadi aktif, diupdate dalam proses pembelajarannya. Dimana
dalam jaringan saraf berdasarkan Hebbian learning, beberapa neuron bisa aktif
secara simultan, dalam pembelajaran jenis ini, hanya satu neuron output yang
aktif dalam satu waktu. Terdapat satu neuron pemenang, dimana aturan ini dikenal
dengan istilah \textit{winner-take-all}. Penentuan neuron pemenang dapat
dilakukan dengan menghitung relasi antara 2 vector, bisa
dengan menggunakan jarak (\textit{distance metric}), dimana semakin kecil
jaraknya, maka relasi semakin tinggi, atau dengan menggunakan tingkat
kemiripan (\textit{similarity measures}), dimana semakin besar nilai
\textit{similarity}, maka relasi akan semakin tinggi. 

Jika $x$ adalah vektor masukan, dan  $w_i$ adalah vektor keluaran ke-$i$, maka
$w_p$, neuron pemenang adalah;
\begin{align}
\label{eq:lvqwin}
	w_p = \arg \min_i d(x, w_i)
\end{align}

Terdapat beberapa metode JST yang mengadopsi aturan ini diantaranya adalah SOM
dan LVQ.
\subsection{Learning Vector Quantization (LVQ)}
\glsreset{lvq}

\Gls{lvq} yang dikembangkan oleh Teuvo Kohonen (1986) \cite{Kohonen-1986b}
merupakan suatu metode pengenalan pola di mana setiap unit output
merepresentasikan suatu kelas atau kategori. Vektor bobot untuk suatu unit
output sering dirujuk sebagai vektor pewakil (\textit{vector reference},
\textit{codebook}, \textit{prototype}) untuk kelas yang direpresentasikan unit
output tersebut. Dalam suatu jaringan LVQ, beberapa unit output vektor pewakil
dapat digunakan untuk setiap kelas. 

Diasumsikan bahwa satu set pola pembelajaran dengan klasifikasi yang diketahui,
diberikan pada jaringan, bersama dengan distribusi awal dari vektor
reference-nya. Setelah pembelajaran, jaringan LVQ mengklasifikasikan suatu
vektor input dengan memasukkannya pada kelas yang sama dengan unit output yang
vektor bobot-nya paling dekat ke vektor input.
Dari sisi arsitektur, karakteristik dari jaringan \gls{lvq} memiliki jaringanlapis tunggal tanpa \textit{hidden layers}, dimana arsitekturnya serupa dengan\textit{Self-Organized Map} tanpa adanya asumsi topologi tertentu. Terdiri darisatu lapis input dengan satu lapis output untuk komputasi. Dalam lapisan output,setiap unit neuron merepresentasikan suatu kelas atau cluster tertentu.

Dalam JST, pada lapisan output umumnya terdapat suatu fungsi yang digunakan
untuk menentukan level aktivasi dari neuron, dimana fungsi tersebut akan
membatasi nilai keluaran pada suatu interval tertentu. Pada \gls{lvq}, fungsi
aktivasi yang digunakan adalah fungsi identitas yang artinya keluaran input sama
dengan masukkannya, $f(x) = x$.

\noindent
Secara umum, algoritma LVQ dapat ditunjukkan pada algoritma \ref{alg:lvq}.

\begin{algorithm}  
\scriptsize 
\caption{Pseudocode Algoritma LVQ}          
\label{alg:lvq}                           
\begin{algorithmic}                    % enter the algorithmic environment
	\STATE Initialize weight vector $W$
	\STATE Initialize learning rate $\alpha_0$
	\STATE Initialize maximum iteration $t_{max}$
	\STATE $t \leftarrow 0$
	\WHILE {$\alpha_t \neq 0$ or $t < t_{max}$}
		\STATE $x \leftarrow $ getNextSample()
		\STATE $train(W, x) \Downarrow$
		\STATE $\qquad \leadsto w \leftarrow $ getClosestPrototipe()
		\STATE $\qquad \leadsto $updatePrototipe($w$)
		\STATE $t \leftarrow t + 1$
	\ENDWHILE
\end{algorithmic}
\end{algorithm}
 
Terdapat beberapa versi dari \gls{lvq} dimana setiap versi merupakan
penyempurnaan dari versi sebelumnya, baik dari sisi konvergensi 
maupun inisialisasi awal prototipe. Berikut akan diuraikan beberapa versi
dari \gls{lvq};

\subsubsection*{LVQ1}
Pada \gls{lvq} versi pertama, setiap pemberian satu sampel data akan
mengakibatkan proses update terhadap satu prototipe. Pada setiap iterasi dari
proses pelatihan, prototipe dengan jarak minimal terhadap input
akan disesuaikan. Proses penyesuaian prototipe tergantung dari hasil proses
klasifikasi. Jika prototipe pemenang adalah sama dengan kategori input, maka
prototipe akan disesuaikan mendekati sampel data. Jika tidak, maka prototipe
pemenang akan disesuaikan menjauhi sampel data. Tahap pembelajaran yang
dilakukan pada LVQ1 dapat diuraikan sebagai berikut;
\begin{enumerate}
  \setlength{\itemsep}{1pt}
  \setlength{\parskip}{0pt}
  \setlength{\parsep}{0pt}
  \item Pilih sampel data $x$,
  \item Tentukan prototipe pemenang $w_p$ seperti pada \ref{eq:lvqwin}.
  \item Sesuaikan prototipe $w_p$ berdasarkan aturan berikut;
  \begin{align}
  \label{eq:lvq1}
  \begin{array}{ll}
  	w_p \leftarrow w_p + \alpha . (x - w_p), &\quad \text{if}\ C_{w_p} = C_x \\
  	w_p \leftarrow w_p - \alpha . (x - w_p), &\quad \text{if}\ C_{w_p} \neq C_x
  	\\
  \end{array}
  \end{align} 
\end{enumerate}

\noindent Nilai $\alpha$ disini adalah laju pembelajaran dengan rentang nilai
antara $0 < \alpha < 1$ dimana nilainya selalu menurun seiring iterasi proses
pembelajaran.

\noindent 
Aturan pembelajaran diatas dapat ditunjukkan lebih detail seperti
yang terlihat pada algoritma \ref{alg:lvq1}
\begin{algorithm}  
\scriptsize 
\caption{Aturan pembelajaran LVQ1 $train(W, x)$}          
\label{alg:lvq1}                           
\begin{algorithmic}                    % enter the algorithmic environment
	\REQUIRE W, x
	
	\STATE $w_p \leftarrow $ ClosestDistanceWeight($x, W$)
	\IF {$C_x = C_{w_p} $}
		\STATE $w_{p, t+1} \leftarrow w_{p,t} + \alpha_t . (x - w_{p,t})$
	\ELSIF {$C_x \neq C_{w_p}$}
		\STATE $w_{p, t+1} \leftarrow w_{p,t} - \alpha_t . (x - w_{p,t})$
	\ENDIF	
	\STATE $\alpha \leftarrow $ getNextLearningRate()
\end{algorithmic}
\end{algorithm}

\subsubsection*{LVQ2}
Pada algoritma LVQ1, proses penyesuaian bobot hanya ditentukan berdasarkan
prototipe pemenang saja. Namun, pada algoritma LVQ2, proses pembelajaran
memperhitungkan prototipe tentangga dimana proses pembelajaran ditentukan
berdasarkan ide dimana jika vektor masukan ($x$) memiliki jarak yang hampir sama
antara pemenang ($w_p$) dan runner-up($w_r$), maka kedua prototipe seharusnyadi-update secara simultan jika $x$ berada pada bagian jendela yang salah.

\noindent
Tahap pembelajaran yang dilakukan pada LVQ2 dapat diuraikan sebagai berikut;
\begin{enumerate}
  \setlength{\itemsep}{1pt}
  \setlength{\parskip}{0pt}
  \setlength{\parsep}{0pt}
  \item Pilih sampel data $x$
  \item Tentukan prototipe pemenang $w_p$ dan pemenang kedua (\textit{runner
  up}) $w_r$
  \item Lakukan pengecekan terhadap $w_p$ dan $w_r$;
  \begin{enumerate}
    \item $w_p$ dan $w_r$ harus berasal dari kategori yang berbeda, $C_{w_p}
    \neq C_{w_r}$
    \item Kategori dari vektor masukan ($C_x$) berasal dari kategori yang sama
    dengan prototipe pemenang kedua, $C_x = C_{w_r}$
    \item Jarak antara vektor masukan ke vektor pemenang ($d(x, w_p)$) dan
    ke vektor runner-up ($d(x, w_r)$) hampir sama. 
    Untuk menentukan seberapa dekat/sama antara $d_p$ dan $d_r$, disini
    digunakan suatu jendela (\textit{window}) untuk membatasi kedua jarak
    tersebut. Pada algoritma LVQ2 diperkenalkan satu parameter baru yakni
    $\omega$ yaitu seberapa lebar jendela yang ditentukan.
    \begin{align}
    \frac{d_p}{d_r} > (1 - \omega)\quad \text{AND}\quad \frac{d_r}{d_p} < (1 -
    \omega)
    \nonumber
    \end{align}
    
    Jika misal nilai $\omega=0.3$, maka kondisi nya menjadi $d_p > 0.7 d_r
   \ \text{AND}\ d_r < 1.3 d_p$. ilustrasi dapat dilihat pada
    \pic~\ref{fig:lvq2}\footnote{sumber:
    {http://ccy.dd.ncu.edu.tw/miat/course/Neural/ch4/}}.
    
    \addFigure{width=0.5\textwidth}{pics/lvq2.png}{fig:lvq2}
    {Ilustrasi sistem jendela pada LVQ2}   \end{enumerate}
    
  \item Jika ketiga kondisi pada langkah (3) terpenuhi, maka lakukan proses
  penyesuaian prototipe sebagai berikut;
  \begin{align}
  w_p \leftarrow w_p - \alpha . (x - w_p) \nonumber \\
  w_r \leftarrow w_r + \alpha . (x - w_r)
  \end{align}
  
  Aturan ini dapat diartikan, jika $x$ berada dalam rentang jendela yang
  ditentukan, tapi dikenali salah ($C_x \neq C(w_p)$), maka jauhkan $w_p$ dari
  distribusi kelas, dan dekatkan $w_r$ dengan distribusi kelas.
\end{enumerate}
\noindent 
Aturan pembelajaran diatas dapat ditunjukkan lebih detail seperti
yang terlihat pada algoritma \ref{alg:lvq2}

\begin{algorithm}  
\scriptsize 
\caption{Aturan pembelajaran LVQ2 $train(W, x)$}          
\label{alg:lvq2}                           
\begin{algorithmic}                    % enter the algorithmic environment
	\REQUIRE W, x
	\STATE $w_p \leftarrow $ ClosesDistanceWeighht($x, W$)
	\STATE $w_r \leftarrow $ RunnerUpClosestDistanceWeight($x, W$)
	\STATE $d_p \leftarrow distance(x, w_p)$
	\STATE $d_r \leftarrow distance(x, w_r)$
	
	\IF {$C_{w_p} \neq C_{w_r}$}
		\IF {$C_x = C_{w_r}$}
			\IF {$\frac{d_p}{d_r} > (1 - \omega)\quad \text{AND}\quad \frac{d_r}{d_p} <
			(1 + \omega)$}
				\STATE $w_{r,t+1} \leftarrow w_{r,t} + \alpha_t . (x - w_{r,t})$
				\STATE $w_{p,t+1} \leftarrow w_{p,t} - \alpha_t . (x - w_{p,t})$
			\ENDIF
		\ENDIF
	\ENDIF
	\STATE $\alpha \leftarrow $ getNextLearningRate()
\end{algorithmic}
\end{algorithm}

\subsubsection*{LVQ2.1}
Algoritma LVQ2.1 merupakan penyempurnaan dari LVQ2 dimana algoritma ini
mengabaikan aturan (2) dari kondisi update prototipe LVQ2. Pada algoritma
LVQ2.1, kategori dari sampel data ($C_x$) \underline{tidak harus sama} dengan
prototipe pemenang kedua ($C_{w_r}$). Persyaratannya adalah minimal salah
satu dari prototipe ($w_p, w_r$) berasal dari kategori yang sama dengan kategori
input ($C_x$). Sedangkan aturan update yang lain masih tetap sama dengan
sebelumnya. Secara lebih detail dapat ditunjukkan pada algoritma
\ref{alg:lvq21}, dimana diasumsikan $C_{w_1} = C_x$.

\begin{algorithm}  
\scriptsize 
\caption{Aturan pembelajaran LVQ2.1 $train(W, x)$}          
\label{alg:lvq21}                           
\begin{algorithmic}                    % enter the algorithmic environment
	\REQUIRE W, x
	\STATE $w_1 \leftarrow $ ClosesDistanceWeighht($x, W$)
	\STATE $w_2 \leftarrow $ RunnerUpClosestDistanceWeight($x, W$)
	\STATE $d_1 \leftarrow distance(x, w_1)$
	\STATE $d_2 \leftarrow distance(x, w_2)$
	
	\IF {$C_{w_1} \neq C_{w_2}$}
		\IF {$\min \left(\frac{d_1}{d_2},\frac{d_2}{d_1}\right) > 
			 \frac{(1 - \omega)}{(1 + \omega)}$}
			\STATE $w_{1,t+1} \leftarrow w_{1,t} + \alpha_t . (x - w_{1,t})$
			\STATE $w_{2,t+1} \leftarrow w_{2,t} - \alpha_t . (x - w_{2,t})$
		\ENDIF
	\ENDIF
	\STATE $\alpha \leftarrow $ getNextLearningRate()
\end{algorithmic}
\end{algorithm}

\subsubsection*{LVQ3}
Algoritma LVQ2.1 memiliki kelemahan dimana prototipe kemungkinan mengalami
divergensi selama proses pembelajaran dilakukan\cite{Sato:1998}. Pada algoritma
LVQ3, koreksi dilakukan terhadap LVQ2.1 dimana untuk memastikan prototipe agar
selalu mendekati distribusi dari kelas. Aturan update prototipe sama dengan
LVQ2.1, hanya saja terdapat aturan tambahan dimana jika kedua prototipe ($w_1,
w_2$) \underline{berasal dari kelas yang sama}, maka update prototipe nya adalah
sebagai berikut;\begin{align}
w_i \leftarrow w_i + \epsilon . \alpha . (x - w_i), \quad \epsilon > 0
\end{align}

\noindent
dimana $i \in {1,2}$, jika $x, w_1, w_2$ berasal dari kelas yang sama.
Berikut pada algoritma \ref{alg:lvq3} untuk metode pembelajaran LVQ3

\begin{algorithm}  
\scriptsize 
\caption{Aturan pembelajaran LVQ3 $train(W, x)$}          
\label{alg:lvq3}                           
\begin{algorithmic}                    % enter the algorithmic environment
	\REQUIRE W, x
	\STATE $w_1 \leftarrow $ ClosesDistanceWeighht($x, W$)
	\STATE $w_2 \leftarrow $ RunnerUpClosestDistanceWeight($x, W$)
	\STATE $d_1 \leftarrow distance(x, w_1)$
	\STATE $d_2 \leftarrow distance(x, w_2)$
	
	\IF {$C_{w_1} \neq C_{w_2}$}
		\IF {$\min \left(\frac{d_1}{d_2},\frac{d_2}{d_1}\right) > 
			 \frac{(1 - \omega)}{(1 + \omega)}$}
			\STATE $w_{1,t+1} \leftarrow w_{1,t} + \alpha_t . (x - w_{1,t})$
			\STATE $w_{2,t+1} \leftarrow w_{2,t} - \alpha_t . (x - w_{2,t})$
		\ENDIF
	\ELSE
		\STATE $w_{1,t+1} \leftarrow w_{1,t} + \epsilon.\alpha_t . (x - w_{1,t})$
		\STATE $w_{2,t+1} \leftarrow w_{2,t} + \epsilon.\alpha_t . (x - w_{2,t})$
	\ENDIF
	\STATE $\alpha \leftarrow $ getNextLearningRate()
\end{algorithmic}
\end{algorithm}  

Yang perlu diperhatikan pada algoritma ini adalah jika masing-masing kategori
hanya direpresentasikan dengan \underline{hanya satu} prototipe, maka algoritma
LVQ3 akan sama dengan algoritma LVQ2.1. Algoritma LVQ3 hanya akan berguna, jika
kategori kelas direpresentasikan dengan lebih dari satu prototipe. 


\subsection{Generalized Learning Vector Quantization (GLVQ)}
\label{ssec:glvq}
\glsreset{glvq}

\Gls{glvq} merupakan algoritma yang dikembangkan oleh A. Sato dan Yamada pada
tahun 1995 \cite{Sato:1995}. Algoritma ini merupakan variasi dari algoritma LVQ
khususnya LVQ2.1 dimana merupakan penurunan dari \textit{cost function} yang
eksplisit, tidak seperti pada algoritma LVQ. Disamping itu algoritma LVQ2.1
juga tidak menjamin konvergensi dari prototipe ke distribusi dari kelas selama
proses pelatihan (\cite{Sato:1995},\cite{Sato:1998}).Metode pembelajaran yang 
digunakan disini berdasarkan atas proses minimisasi dari cost function,
\emph{miss-classification error}, dengan menggunakan metode optimasi gradient
descent.

Diberikan $w_1$ adalah prototipe terdekat berasal dari kategori
yang sama dengan kategori vektor masukan (($C_{w_1} = C_x$)), dan $w_2$ adalah
prototipe terdekat yang bukan berasal dari kategori vektor masukan ($C_{w_2} \neq
C_x$). \emph{miss-classification error} $\varphi(x)$ dapat dihitung dengan
menggunakan persamaan \ref{eq:mce};
 
\begin{align}
\label{eq:mce}
	\varphi(x) = \frac{d_1 - d_2}{d_1 + d_2}
\end{align}

\noindent dimana $d_1$ dan $d_2$ adalah jarak antara $x$ dari $w_1$ dan $w_2$.
nilai dari $\varphi(x)$ diantara $-1$ dan $+1$. Jika $\varphi(x)$ negatif, maka
$x$ dikenali secara benar, sedangkan jika positif, maka $x$ dikenali secara
salah. Untuk memperbaiki error rate, maka $\varphi(x)$ harus diturunkan terhadap
semua vektor masukan. Sehingga, kriteria dari proses pembelajaran adalah
meminimisasi cost function $S$ sebagai berikut;

\begin{align}
\label{eq:costS}
	S = \sum_{i=1}^{N} f(\varphi(x)), 
\end{align}

\noindent dimana $N$ adalah jumlah dari vektor masukan untuk training, dan
$f(\varphi(x))$ adalah fungsi monoton naik. untuk meminimalkan $S$, $w_1$ dan
$w_2$ diupdate berdasarkan metode steepest descent dengan nilai laju
pembelajaran $\alpha$ sebagai berikut;

\begin{align}
\label{eq:genuprule}
	w_i \leftarrow w_i - \alpha \frac{\delta S}{\delta w_i}, i = 1, 2
\end{align}


\noindent Jika fungsi diskriminan yang digunakan adalah menggunakan
\textit{squared euclidean distance} $d_i = \lvert x - w_i\rvert ^2$,  maka akan
didapat;

\begin{align}
\label{eq:turunan1a}
	\frac{\delta S}{\delta w_1} =  
	\frac{\delta S}{\delta \varphi} \frac{\delta \varphi}{\delta d_1} \frac{\delta
	d_1}{\delta w_1} =
	- \frac{\delta f}{\delta \varphi} \frac{4d_2}{(d_1 + d_2)^2} (x - w_1)
\end{align}

\begin{align}
\label{eq:turunan1b}
	\frac{\delta S}{\delta w_2} =  
	\frac{\delta S}{\delta \varphi} \frac{\delta \varphi}{\delta d_2} \frac{\delta
	d_2}{\delta w_2} =
	- \frac{\delta f}{\delta \varphi} \frac{4d_1}{(d_1 + d_2)^2} (x - w_2)
\end{align}

\noindent Sehingga, aturan pembelajaran dari algoritma \gls{glvq} dapat ditulis
sebagai berikut;

\begin{align}
\label{eq:glvq-rulea}
	w_1 \leftarrow w_1 + \alpha   
	\frac{\delta f}{\delta \varphi} \frac{d_2}{(d_1 + d_2)^2} (x - w_1)
\end{align}

\begin{align}
\label{eq:glvq-ruleb}
	w_2 \leftarrow w_2 - \alpha   
	\frac{\delta f}{\delta \varphi} \frac{d_1}{(d_1 + d_2)^2} (x - w_2)
\end{align}

$\frac{\delta f}{\delta \varphi}$ dapat dilihat sebagai \emph{gain factor} untuk
proses update prototipe dan nilai-nya tergantunf pada $x$. Ini artinya, 
$\frac{\delta f}{\delta \varphi}$ merupakan bobot untuk setiap $x$. Untuk
menurunkan error rate, maka akan efektif jika proses update prototipe
menggunakan vektor input yang berada di class boundaries, sehingga decision
boundaries akan digeser menuju batas bayes. Dengan demikian, $f(\varphi)$ harus
merupakan fungsi monoton naik yang non-linear, dan dianggap bahwa kemampuan
pengenalan tergantung pada definisi fungsi $f(\varphi)$ .

Pada \gls{glvq}, fungsi monoton naik yang digunakan adalah fungsi sigmoid;
\begin{align}
\label{eq:sigmoid}
	f(\varphi, t) = \frac{1}{1 + e^{-\varphi t}} \\
\label{eq:deltasigmoid}
	\frac{\delta f}{\delta \varphi} = f(\varphi, t) (1 - f(\varphi , t))
\end{align} 

\noindent dimana $\frac{\delta f}{\delta \varphi}$ memiliki puncak yang
tunggal pada $\varphi=0$, semakin bertambah nilai $t$ maka lebar dari puncak
semakin mengecil dan vektor masukan yang mempengaruhi proses pembelajaran secara
gradual dibatasi pada decision boundaries tersebut.
 
Seperti yang telah disebutkan diatas, keunggulan dari \gls{glvq} adalah menjamin
konvergensi dari prototipe akan mendekati distribusi dari kategori kelas selama
pelatihan. Keungulan yang lain adalah bahwa \gls{glvq} tidak sensitif terhadap
inisialisasi bobot awal yang umumnya dialami oleh LVQ standar \cite{Sato:1999}. 

 
\subsection{Fuzzy-Neuro Learning Vector Quantization (FNLVQ)}

\Gls{fnlvq} merupakan algoritma pembelajaran yang berbasis kompetisi yang
dikembangkan oleh Kusumoputro dan Wisnu J \cite{Kusumoputro:2002} dimana
algoritma ini diaplikasikan pada sistem pengenalan aroma.  Algoritma ini dikembangkan
berdasarkan algoritma LVQ dengan menggunakan teori fuzzy dimana aktifasi
dari neuron ditunjukkan dalam bentuk nilai fuzzy karena dimotivasi
oleh ketidakjelasan (\emph{fuzzines}) dari data yang dihasilkan akibat dari
kesalahan pengukuran oleh alat. Proses fuzzifikasi dari semua komponen prototipe
dan vektor masukan dikalkulasi melalui proses normalisasi dengan menggunakan
fungsi keanggotaan segitiga, dengan nilai derajat keanggotaan maksimal adalah 1.
Fungsi keanggotaan segitiga sangat umum digunakan karena sifatnya yang sangat
sederhana dan mudah untuk diimplementasikan. Distribusi data direpresentasikan
pada prototipe dengan nilai min, mean dan max, yaitu $F = (f_l, f, f_r)$. $f$
adalah pusat (\emph{center}) dari distribusi sampel data, sedangkan $f_l$ dan
$f_r$ secara berurutan adalah nilai minimum dan maksimum sampel data. 

Karena neuron pada \gls{fnlvq} menggunakan fuzzy number, maka konsep jarak
euclid yang digunakan pada standar \gls{lvq} dimodifikasi menggunakan fuzzy
similarity dimana dihitung dengan menggunakan operasi MAX-MIN antara vektor
input dengan prototipe. Dengan model seperti ini, arsitektur dari jaringan
disesuaikan untuk mengakomodasi operasi MAX-MIN dari dua vektor. Arsitektur
\gls{fnlvq} dapat dilihat pada \pic~\ref{fig:fnlvqarch}, dimana jaringan terdiri
dari lapisan input , satu lapisan tersembunyi (\emph{hidden layer}) dan lapisan
output. Lapisan tersembunyi disini merupakan representasi dari vektor referensi
yang terdiri dari beberapa fungsi keanggotaan yang berkorespondensi dengan
setiap fitur masukan , dan setiap kategori  kelas direpresentasikan dengan satu
vektor referensi, dalam hal ini disebut dengan \emph{cluster}.

\addFigure{width=0.8\textwidth}{pics/fnlvqarch.png}{fig:fnlvqarch}{Arsitektur
dari fuzzy neuro LVQ digunakan dalam sistem pengenalan aroma.}

Diberikan $x(t)$ adalah vektor masukan. $h_x(t)$ adalah fungsi keanggotaan dari
$x$, sedangkan $w_i$ adalah vektor referensi dari kategori $i$ dan $h_{w_i}$
adalah fungsi keanggotaan untuk $w_i$. Tingkat kemiripan antara setiap
\emph{cluster} ($w_i$) pada \emph{hidden layer} dengan vektor masukan ($x(t)$)
dihitung dengan menggunakan \emph{fuzzy similarity} $\mu_i(t)$ dengan
menggunakan operasi max sebagai berikut;

\begin{align}
\mu_i(t) = \max [h_x(t) \wedge h_{w_i}(t)], \quad i = 1, 2, \dots, m
\end{align}

\noindent dimana $m$ adalah maksimal jumlah kategori dari aroma.

Fungsi aktifasi yang digunakan pada tiap \emph{cluster} adalah dengan
menggunakan operasi minimum untuk semua komponen yang ada didalamnya, 
dimana nantinya nilai fuzzy similarity $\mu(t)$ akan dipropagasikan ke neuron
keluaran.

\begin{align}
\mu(t) = \min [\mu_i(t)]
\end{align}

\noindent kemudian dicari nilai terbesar nilai similarity $\mu(t)$
setiap neuron output untuk menentukan neuron pemenang. Jika neuron pemenang
memiliki $\mu(t)$ sama dengan 1, maka vektor masukan dan vektor
referen adalah sama, sedangkan jika $\mu(t)$ sama dengan 0, maka vektor
masukan dan vektor referen tidak mirip sama sekali.

Aturan pembelajaran dari algoritma \gls{fnlvq} terdiri dari tiga kondisi yang
mungkin terjadi diantaranya; (1) Jika jaringan dapat mengenali masukan dengan
benar, (2) Jika jaringan salah mengenali vektor masukan, dan (3) Jika tidak
terdapat interseksi fuzzy set antara vektor masukan dan prototipe. Berikut
adalah aturan pembelajaran untuk setiap kondisi;
\begin{enumerate}
  \setlength{\itemsep}{1pt}
  \setlength{\parskip}{0pt}
  \setlength{\parsep}{0pt}
  \item Jika jaringan mengenali vektor masukan dengan benar, $C_x = C_{w_p}$
  maka prototipe dari cluster pemenang diupdate sesuai dengan;
  \begin{enumerate}
  	\item Posisi pusat dari prototipe digeser mendekati vektor masukan
  	\begin{align}
  	w_i(t+1) = w_i(t) + \alpha(t) \left((1-\mu(t))\times(x(t) - w_i(t))  \right)
  	\end{align}
  	\item Tingkatkan kemampuan pengenalan prototipe  dengan memperlebar fungsi
  	keanggotaan dari prototipe dengan aturan sebagai berikut;
  	\begin{enumerate}
  	  \item Modifikasi dengan faktor konstan
  	  \begin{align}
  	  f_l(t+1) &= f_l(t) - (1+\beta) (f(t) - f_l(t))  \\
  	  f_r(t+1) &= f_r(t) - (1+\beta) (f_r(t) - f(t)) \nonumber \\
  	  f(t+1)   &= w_i(t+1) \nonumber
  	  \end{align}
  	  
  	  \item Modifikasi dengan faktor variabel
	  \begin{align}
  	  f_l(t+1) &= f_l(t) - (1 - \mu)(1+\eta)(f(t) - f_l(t))  \\
  	  f_r(t+1) &= f_r(t) - (1 + \mu)(1+\eta)(f_r(t) - f(t)) \nonumber \\
  	  f(t+1)   &= w_i(t+1) \nonumber
  	  \end{align}  	  
  	\end{enumerate}
  \end{enumerate}
  
  \item Jika jaringan salah mengenali vektor masukan, $C_x \neq C_{w_p}$ maka
  prototipe dari cluster pemenang diupdate sesuai aturan;
  \begin{enumerate}
    \item Posisi pusat dari prototipe digeser menjauhi vektor masukan
  	\begin{align}
  	w_i(t+1) = w_i(t) - \alpha(t) \left((1-\mu(t))\times(x(t) - w_i(t))  \right)
  	\end{align}
  	\item Turunkan kemampuan pengenalan prototipe dengan mempersempit fungsi
  	keanggotaan dari prototipe dengan aturan sebagai berikut;
  	\begin{enumerate}
  	  \item Modifikasi dengan faktor konstan
  	  \begin{align}
  	  f_l(t+1) &= f_l(t) + (1+\gamma) (f(t) - f_l(t)) \\
  	  f_r(t+1) &= f_r(t) - (1+\gamma) (f_r(t) - f(t)) \nonumber \\
  	  f(t+1)   &= w_i(t+1) \nonumber 
  	  \end{align}
  	  
  	  \item Modifikasi dengan faktor variabel
	  \begin{align}
  	  f_l(t+1) &= f_l(t) + (1 - \mu)(1-\kappa)(f(t) - f_l(t)) \\
  	  f_r(t+1) &= f_r(t) - (1 - \mu)(1-\kappa)(f_r(t) - f(t)) \nonumber \\
  	  f(t+1)   &= w_i(t+1) \nonumber
  	  \end{align}  	  
  	\end{enumerate}
  \end{enumerate}
  
  \item Jika fungsi keanggotaan prototipe tidak memiliki interseksi dengan
  vektor masukan, maka fungsi keanggotaan prototipe diupdate berdasarkan aturan
  sebagai berikut;
  \begin{align}
  w_i(t+1) = \xi(t).w_i(t)
  \end{align}
\end{enumerate}

\noindent dimana nomenklatur yang digunakan adalah sebagai berikut;

\begin{tabular}{llp{0.8\textwidth}}
$w_{i}(t+1)$ &=& prototipe pemenang setelah di-update  \\
$w_{i}(t)$ 	 &=& prototipe pemenang sebelum di-update \\
$\alpha(t)$  &=& laju pembelajaran, nilai monoton turun $(0 < \alpha \le 1))$,
 yang didefinisikan sebagai berikut;
\end{tabular}

\begin{small}
	\begin{align}\label{eq:learning_rate}
		\alpha(t+1) &= 0.9999 \alpha(t) \\[0.2cm]
		\alpha(0) &= 0.05 \nonumber
	\end{align}
\end{small}

\begin{tabular}{llp{0.8\textwidth}}
$\beta, \gamma$ &=& nilai konstan yang digunakan dalam proses pelebaran
dan penyempitan fungsi keanggotaan dengan interval [0,1] \\
$\eta, \kappa$ &=& nilai variabel yang digunakan dalam proses pelebaran
dan penyempitan fungsi keanggotaan dengan definisi;
\end{tabular}

\begin{small}
	\begin{align}\label{eq:fuzziness_value}
	\eta(t+1) &= 1/100 {1-\alpha(t+1)} \\[0.2cm]
	\kappa(t+1) &= 1 - \alpha(t+1) \nonumber
	\end{align}
\end{small}

\noindent dimana nilai $\xi$ adalah konstan dengan = $\xi=1.1$.

Terdapat beberapa penelitian yang dilakukan untuk meningkatkan
kinerja dari algoritma FNLVQ. Kusumoputro et.al. \cite{Kusumoputro:2002b} 
menggunakan Matrix Similarity Analysis (MSA) menangani kelemahan dari FNLVQ
standar dimana sensitif terhadap pemilihan prototipe awal. Untuk
menanggulanginya, dalam proses pelatihan akan dipilih bobot terbaik untuk
setiap iterasi dengan menggunakan matrix similarity sebagai  \emph{fitness
function} nya, sehingga selain menggunakan maksimal epoch, lama proses
pembelajaran juga dapat ditentukan berdasarkan nilai matrix yang didapat 
yang digunakan sebagai nilai threshold. Matrix ideal yang diharapkan untuk 
mendapatkan kinerja terbaik adalah jika menghasilkan matrik identitas.

Selain itu, pendekatan lain yang dilakukan untuk menangani
sensitifitas pemilihan prototipe awal adalah penelitian yang dilakukan oleh
Rohmatullah dalam tesis-nya \cite{Rochmatullah:2009}, dimana pendekatan yang
dilakukan menggunakan konsep Particle Swarm Optimization (PSO) digabungkan
dengan FNLVQ-MSA. Tujuan dari PSO ini adalah untuk menentukan inisialisasi
vektor awal terbaik yang dihasilkan dari proses pencarian dengan menggunakan
faktor kognitif dan sosial sebagai salah satu parameter pencarian. Namun,
kelemahannya adalah, proses komputasi yang dibutuhkan sangat lama.

% Dari beberapa uraian diatas, dapat diberikan
% ilustrasi mengenai pohon algoritma seperti yang terlihat pada \pic~\ref{fig:pohon-alg}
% 
% \addFigure{width=0.8\textwidth}{pics/pohon-alg.png}{fig:pohon-alg}{Ilustrasi
% pohon algoritma}












